home *** CD-ROM | disk | FTP | other *** search
/ STraTOS 1997 April & May / STraTOS 1 - 1997 April & May.iso / CD01 / PRGMANIA / QEDSRC / TASTEN.C < prev    next >
Encoding:
C/C++ Source or Header  |  1997-01-14  |  23.0 KB  |  1,060 lines
  1. #include "global.h"
  2. #include "ausgabe.h"
  3. #include "block.h"
  4. #include "clipbrd.h"
  5. #include "edit.h"
  6. #include "find.h"
  7. #include "icon.h"
  8. #include "kurzel.h"
  9. #include "makro.h"
  10. #include "options.h"
  11. #include "qed.h"
  12. #include "scroll.h"
  13. #include "set.h"
  14. #include "text.h"
  15. #include "umbruch.h"
  16. #include "windows.h"
  17. #include "tasten.h"
  18.  
  19. typedef enum {UP, DOWN, LEFT, RIGHT} DIRECTION;
  20.  
  21. LOCAL WORD    save_col[130];     /* Gerettete Zeile für Undo */
  22. LOCAL WORD    save_len;
  23. LOCAL WORD    cntrl_y_col[130]; /* Gerettete Zeile für cntrl-y */
  24. LOCAL WORD    cntrl_y_len;
  25.  
  26. LOCAL VOID text_end(TEXTP t_ptr);
  27. LOCAL VOID text_start(TEXTP t_ptr);
  28.  
  29. LOCAL VOID line_up(TEXTP t_ptr);
  30. LOCAL VOID page_up(TEXTP t_ptr);
  31.  
  32. LOCAL VOID line_down(TEXTP t_ptr);
  33. LOCAL VOID page_down(TEXTP t_ptr);
  34.  
  35. LOCAL VOID char_right(TEXTP t_ptr);
  36. LOCAL VOID line_end(TEXTP t_ptr);
  37.  
  38. LOCAL VOID line_start(TEXTP t_ptr);
  39.  
  40. LOCAL VOID tabulator(TEXTP t_ptr);
  41.  
  42. LOCAL VOID line_delete(TEXTP t_ptr, BOOLEAN add);
  43. LOCAL VOID char_delete(TEXTP t_ptr);
  44.  
  45. LOCAL VOID word_delete(TEXTP t_ptr);
  46. LOCAL VOID word_bs(TEXTP t_ptr);
  47.  
  48. LOCAL VOID word_left(TEXTP t_ptr);
  49. LOCAL VOID word_right(TEXTP t_ptr);
  50.  
  51.  
  52. GLOBAL VOID get_undo_col(TEXTP t_ptr)
  53. {
  54.     if (!test_col_anders() || t_ptr->ypos!=undo_y)
  55.     {
  56.         undo_y = t_ptr->ypos;
  57.         save_len = t_ptr->cursor_line->len;
  58.         COPYW((UBYTE*)save_col,TEXT(t_ptr->cursor_line),save_len);
  59.     }
  60.     add_undo(COL_ANDERS);
  61. }
  62.  
  63. GLOBAL VOID do_undo_col(TEXTP t_ptr, WORD undo)
  64. {
  65.     LINEP undo_col;
  66.     WORD    help[130];
  67.     UBYTE *str;
  68.     WORD    length;
  69.  
  70.     if (undo==COL_ANDERS)
  71.     {
  72.         undo_col = get_line(&t_ptr->text,undo_y);
  73.         length = undo_col->len;
  74.         COPYW((UBYTE*)help,TEXT(undo_col),length);
  75.  
  76.         str = REALLOC(&undo_col,0,save_len-length);
  77.         COPYB(str,(UBYTE*)save_col,save_len);
  78.  
  79.         COPYW((UBYTE*)save_col,(UBYTE*)help,length);
  80.         save_len = length;
  81.  
  82.         t_ptr->moved++;
  83.         make_chg(t_ptr->link,LINE_CHANGE,undo_y);
  84.         make_chg(t_ptr->link,POS_CHANGE,0);             /* wg. moved */
  85.         t_ptr->cursor_line = undo_col;
  86.         add_undo(COL_ANDERS);
  87.     }
  88. }
  89.  
  90. LOCAL BOOLEAN pos_move(TEXTP t_ptr, LONG delta)
  91. {
  92.     LINEP lauf;
  93.  
  94.     lauf = t_ptr->cursor_line;
  95.     if (!t_ptr->up_down)
  96.     {
  97.         t_ptr->desire_x = BildPos(t_ptr->xpos,lauf,t_ptr->loc_opt->tab,t_ptr->loc_opt->tabsize);
  98.         t_ptr->up_down = TRUE;
  99.     }
  100.     if (delta < 0) /* rauf */
  101.     {
  102.         if (t_ptr->ypos==0) return FALSE;
  103.         delta = -delta;
  104.         if (delta > t_ptr->ypos)
  105.             delta = t_ptr->ypos;
  106.         t_ptr->ypos -= delta;
  107.         while (--delta>=0) VORG(lauf);
  108.         t_ptr->cursor_line = lauf;
  109.         t_ptr->xpos = InterPos(t_ptr->desire_x,lauf,t_ptr->loc_opt->tab,t_ptr->loc_opt->tabsize);
  110.         return TRUE;
  111.     }
  112.     else if (delta>0) /* runter */
  113.     {
  114.         LONG rest = t_ptr->text.lines-t_ptr->ypos-1;
  115.  
  116.         if (rest==0) return FALSE;
  117.         if (delta>rest) delta = (WORD)rest;
  118.         t_ptr->ypos += delta;
  119.         while (--delta>=0)    NEXT(lauf);
  120.         t_ptr->cursor_line = lauf;
  121.         t_ptr->xpos = InterPos(t_ptr->desire_x,lauf,t_ptr->loc_opt->tab,t_ptr->loc_opt->tabsize);
  122.         return TRUE;
  123.     }
  124.     return FALSE;
  125. }
  126.  
  127. LOCAL VOID text_start(TEXTP t_ptr)
  128. {
  129.     t_ptr->up_down = FALSE;
  130.     t_ptr->cursor_line = FIRST(&t_ptr->text);
  131.     t_ptr->xpos = 0;
  132.     t_ptr->ypos = 0;
  133.     make_chg(t_ptr->link,POS_CHANGE,0);
  134. }
  135.  
  136. LOCAL VOID text_end(TEXTP t_ptr)
  137. {
  138.     t_ptr->up_down = FALSE;
  139.     t_ptr->cursor_line = LAST(&t_ptr->text);
  140.     t_ptr->xpos = 0;
  141.     t_ptr->ypos = t_ptr->text.lines-1;
  142.     make_chg(t_ptr->link,POS_CHANGE,0);
  143. }
  144.  
  145. LOCAL VOID page_up(TEXTP t_ptr)
  146. {
  147.     WINDOWP window = get_window(t_ptr->link);
  148.  
  149.     if (pos_move(t_ptr, - window->w_hight))
  150.     {
  151.         make_chg(t_ptr->link,MOVE_DOWN,window->w_hight);
  152.         make_chg(t_ptr->link,POS_CHANGE,0);
  153.     }
  154.     else
  155.         end_play();
  156. }
  157.  
  158. LOCAL VOID line_up(TEXTP t_ptr)
  159. {
  160.     LINEP lauf = t_ptr->cursor_line;
  161.     if (!t_ptr->up_down)
  162.     {
  163.         t_ptr->desire_x = BildPos(t_ptr->xpos,lauf,t_ptr->loc_opt->tab,t_ptr->loc_opt->tabsize);
  164.         t_ptr->up_down = TRUE;
  165.     }
  166.     if (t_ptr->ypos)
  167.     {
  168.         VORG(lauf);
  169.         t_ptr->cursor_line = lauf;
  170.         t_ptr->xpos = InterPos(t_ptr->desire_x,lauf,t_ptr->loc_opt->tab,t_ptr->loc_opt->tabsize);
  171.         t_ptr->ypos--;
  172.         make_chg(t_ptr->link,POS_CHANGE,0);
  173.     }
  174.     else
  175.         end_play();
  176. }
  177.  
  178. LOCAL VOID page_down(TEXTP t_ptr)
  179. {
  180.     WINDOWP window = get_window(t_ptr->link);
  181.  
  182.     if (pos_move(t_ptr, window->w_hight))
  183.     {
  184.         make_chg(t_ptr->link,MOVE_UP,window->w_hight);
  185.         make_chg(t_ptr->link,POS_CHANGE,0);
  186.     }
  187.     else
  188.         end_play();
  189. }
  190.  
  191. LOCAL VOID line_down(TEXTP t_ptr)
  192. {
  193.     LINEP lauf = t_ptr->cursor_line;
  194.  
  195.     if (!t_ptr->up_down)
  196.     {
  197.         t_ptr->desire_x = BildPos(t_ptr->xpos,lauf,t_ptr->loc_opt->tab,t_ptr->loc_opt->tabsize);
  198.         t_ptr->up_down = TRUE;
  199.     }
  200.     if (!IS_LAST(t_ptr->cursor_line))
  201.     {
  202.         NEXT(lauf);
  203.         t_ptr->cursor_line = lauf;
  204.         t_ptr->xpos = InterPos(t_ptr->desire_x,lauf,t_ptr->loc_opt->tab,t_ptr->loc_opt->tabsize);
  205.         t_ptr->ypos++;
  206.         make_chg(t_ptr->link,POS_CHANGE,0);
  207.     }
  208.     else
  209.         end_play();
  210. }
  211.  
  212. LOCAL VOID line_start(TEXTP t_ptr)
  213. {
  214.     t_ptr->up_down = FALSE;
  215.     t_ptr->xpos = 0;
  216.     make_chg(t_ptr->link,POS_CHANGE,0);
  217. }
  218.  
  219. LOCAL VOID line_end(TEXTP t_ptr)
  220. {
  221.     t_ptr->up_down = FALSE;
  222.     t_ptr->xpos = t_ptr->cursor_line->len;
  223.     make_chg(t_ptr->link,POS_CHANGE,0);
  224. }
  225.  
  226. GLOBAL VOID char_left(TEXTP t_ptr)                /* -> kurzel.c */
  227. {
  228.     if (t_ptr->xpos)
  229.     {
  230.         t_ptr->xpos--;
  231.         make_chg(t_ptr->link,POS_CHANGE,0);
  232.     }
  233.     else if (t_ptr->ypos)
  234.     {
  235.         LINEP lauf = t_ptr->cursor_line;
  236.  
  237.         VORG(lauf);
  238.         t_ptr->cursor_line = lauf;
  239.         t_ptr->xpos = lauf->len;
  240.         t_ptr->ypos--;
  241.         make_chg(t_ptr->link,POS_CHANGE,0);
  242.     }
  243.     else
  244.         end_play();
  245. }
  246.  
  247. LOCAL VOID char_right(TEXTP t_ptr)
  248. {
  249.     LINEP lauf = t_ptr->cursor_line;
  250.  
  251.     if (t_ptr->xpos<lauf->len)
  252.     {
  253.         t_ptr->xpos++;
  254.         make_chg(t_ptr->link,POS_CHANGE,0);
  255.     }
  256.     else if (!IS_LAST(lauf))
  257.     {
  258.         NEXT(lauf);
  259.         t_ptr->cursor_line = lauf;
  260.         t_ptr->xpos = 0;
  261.         t_ptr->ypos++;
  262.         make_chg(t_ptr->link,POS_CHANGE,0);
  263.     }
  264.     else
  265.         end_play();
  266. }
  267.  
  268.  
  269. GLOBAL WORD col_offset(LINEP col)
  270. /* Wieviel WS-Zeichen stehen am Anfang der Zeile */
  271. {
  272.     WORD    pos;
  273.     UBYTE c, *str;
  274.  
  275.     pos = 0;
  276.     str = TEXT(col);
  277.     c = *str++;
  278.     while ((c=='\t' || c==' ') && pos<col->len)
  279.     {
  280.         pos++;
  281.         c = *str++;
  282.     }
  283.     return pos;
  284. }
  285.  
  286. GLOBAL WORD einrucken(LINEP *col)
  287. {
  288.     LINEP vor_col;
  289.     WORD    length;
  290.  
  291.     vor_col = (*col)->vorg;
  292.     if (!IS_HEAD(vor_col))
  293.     {
  294.         length = col_offset(vor_col);
  295.         if ((*col)->len+length>MAX_LINE_LEN)
  296.         {
  297.             inote(1, TOOLONG, MAX_LINE_LEN);
  298.             return 0;
  299.         }
  300.         INSERT(col, 0, length, TEXT(vor_col));
  301.     }
  302.     else
  303.         length = 0;
  304.     return(length);
  305. }
  306.  
  307. GLOBAL VOID char_cr(TEXTP t_ptr)                 /* -> kurzel.c */
  308. {
  309.     t_ptr->blk_mark_mode = FALSE;
  310.     t_ptr->up_down = FALSE;
  311.     clr_undo();
  312.     if (t_ptr->block)
  313.         blk_delete(t_ptr);
  314.     t_ptr->moved++;
  315.     col_split(&t_ptr->cursor_line,t_ptr->xpos);
  316.     t_ptr->cursor_line->info |= ABSATZ;
  317.     t_ptr->text.lines++;
  318.     NEXT(t_ptr->cursor_line);
  319.     t_ptr->ypos++;
  320.     if (t_ptr->loc_opt->einruecken)
  321.         t_ptr->xpos = einrucken(&t_ptr->cursor_line);
  322.     else
  323.         t_ptr->xpos = 0;
  324.  
  325.     make_chg(t_ptr->link,SCROLL_DOWN,t_ptr->ypos);
  326.     make_chg(t_ptr->link,LINE_CHANGE,t_ptr->ypos-1);
  327.     make_chg(t_ptr->link,LINE_CHANGE,t_ptr->ypos);
  328.     make_chg(t_ptr->link,POS_CHANGE,0);
  329.     if (t_ptr->loc_opt->umbrechen)
  330.         umbruch(t_ptr);
  331. }
  332.  
  333. GLOBAL VOID char_bs(TEXTP t_ptr)             /* -> kurzel.c */
  334. {
  335.     if (IS_FIRST(t_ptr->cursor_line) && t_ptr->xpos==0)
  336.     {
  337.         end_play();             /* Makro beenden */
  338.     }
  339.     else
  340.     {
  341.         char_left(t_ptr);
  342.         char_delete(t_ptr);
  343.     }
  344. }
  345.  
  346. LOCAL VOID tabulator(TEXTP t_ptr)
  347. {
  348.     t_ptr->blk_mark_mode = FALSE;
  349.     t_ptr->up_down = FALSE;
  350.     if (t_ptr->block)
  351.         blk_delete(t_ptr);
  352.     if (t_ptr->loc_opt->tab)
  353.         char_insert(t_ptr, '\t');
  354.     else
  355.     {
  356.         WORD xw, tabsize = t_ptr->loc_opt->tabsize;
  357.  
  358.         xw = BildPos(t_ptr->xpos,t_ptr->cursor_line,t_ptr->loc_opt->tab,tabsize);
  359.         xw = tabsize-(xw%tabsize);
  360.         while((--xw) >= 0)
  361.             char_insert(t_ptr, ' ');
  362.     }
  363. }
  364.  
  365. GLOBAL VOID char_swap(TEXTP t_ptr)        /* -> menu.c */
  366. {
  367.     UBYTE c;
  368.     WORD    x;
  369.  
  370.     x = t_ptr->xpos;
  371.     if (x > 0 && x < t_ptr->cursor_line->len)
  372.     {
  373.         get_undo_col(t_ptr);
  374.         c = TEXT(t_ptr->cursor_line)[x];
  375.         TEXT(t_ptr->cursor_line)[x] = TEXT(t_ptr->cursor_line)[x-1];
  376.         TEXT(t_ptr->cursor_line)[x-1] = c;
  377.         t_ptr->xpos++;
  378.         t_ptr->moved++;
  379.         make_chg(t_ptr->link,LINE_CHANGE,t_ptr->ypos);
  380.         make_chg(t_ptr->link,POS_CHANGE,0);
  381.     }
  382. }
  383.  
  384. GLOBAL VOID char_insert(TEXTP t_ptr, UBYTE c)
  385. {
  386.     t_ptr->up_down = FALSE;
  387.     if (t_ptr->block)
  388.         blk_delete(t_ptr);
  389.     get_undo_col(t_ptr);
  390.     if (overwrite && t_ptr->xpos < t_ptr->cursor_line->len)
  391.     {
  392.         TEXT(t_ptr->cursor_line)[t_ptr->xpos] = c;
  393.     }
  394.     else
  395.     {
  396.         if (t_ptr->cursor_line->len == MAX_LINE_LEN)
  397.         {
  398.             inote(1, TOOLONG, MAX_LINE_LEN);
  399.             return;
  400.         }
  401.         *(REALLOC(&t_ptr->cursor_line,t_ptr->xpos,1)) = c;
  402.     }
  403.     t_ptr->xpos++;
  404.     t_ptr->moved++;
  405.     make_chg(t_ptr->link,LINE_CHANGE,t_ptr->ypos);
  406.     make_chg(t_ptr->link,POS_CHANGE,0);
  407.     if (t_ptr->loc_opt->umbrechen)
  408.         umbruch(t_ptr);
  409. }
  410.  
  411. LOCAL VOID word_delete(TEXTP t_ptr)
  412. /* Löschen bis zum nächsten Wortanfang */
  413. {
  414.     WORD xpos = t_ptr->xpos;
  415.     BOOLEAN    in_word = FALSE;
  416.  
  417.     t_ptr->blk_mark_mode = FALSE;
  418.     t_ptr->up_down = FALSE;
  419.     if (!t_ptr->block)
  420.     {
  421.         blk_mark(t_ptr,0);
  422.         while (setin(t_ptr->loc_opt->wort_set,TEXT(t_ptr->cursor_line)[xpos])
  423.                 && t_ptr->cursor_line->len > xpos)
  424.         {
  425.             xpos++;
  426.             in_word = TRUE;
  427.         }
  428.         if (!in_word)
  429.             while (!setin(t_ptr->loc_opt->wort_set,TEXT(t_ptr->cursor_line)[xpos])
  430.                     && t_ptr->cursor_line->len > xpos)
  431.             xpos++;
  432.         t_ptr->xpos = xpos;
  433.         blk_mark(t_ptr,1);
  434.     }
  435.     blk_delete(t_ptr);
  436. }
  437.  
  438. LOCAL VOID word_bs(TEXTP t_ptr)
  439. /* Löschen wortweise nach links */
  440. {
  441.     WORD        xpos = t_ptr->xpos - 1;
  442.     BOOLEAN    in_word = FALSE;
  443.  
  444.     t_ptr->blk_mark_mode = FALSE;
  445.     t_ptr->up_down = FALSE;
  446.     if (!t_ptr->block)
  447.     {
  448.         blk_mark(t_ptr,0);
  449.         while (setin(t_ptr->loc_opt->wort_set, TEXT(t_ptr->cursor_line)[xpos])
  450.                     && xpos > 0)
  451.         {
  452.             xpos--;
  453.             in_word = TRUE;
  454.         }
  455.         if (!in_word)
  456.             while (!setin(t_ptr->loc_opt->wort_set, TEXT(t_ptr->cursor_line)[xpos])
  457.                         && xpos > 0)
  458.                 xpos--;
  459.         if (xpos == 0 && t_ptr->xpos == 1)        /* erstes Zeichen */
  460.             t_ptr->xpos = 0;
  461.         else
  462.             t_ptr->xpos = xpos + 1;
  463.         blk_mark(t_ptr,1);
  464.     }
  465.     blk_delete(t_ptr);
  466. }
  467.  
  468. LOCAL VOID line_delete(TEXTP t_ptr, BOOLEAN add)
  469. {
  470.     LINEP col = t_ptr->cursor_line;
  471.  
  472.     cntrl_y_len = col->len;
  473.     COPYW((UBYTE*)cntrl_y_col,TEXT(col),cntrl_y_len);
  474.     t_ptr->xpos = 0;
  475.     blk_mark(t_ptr,0);
  476.     if (IS_LAST(col))
  477.     /* letzte Zeile im Text nur kürzen */
  478.     {
  479.         t_ptr->xpos = col->len;
  480.         blk_mark(t_ptr,1);
  481.     }
  482.     else
  483.     {
  484.         NEXT(col);
  485.         t_ptr->cursor_line = col;
  486.         t_ptr->ypos++;
  487.         blk_mark(t_ptr,1);
  488.     }
  489.     blk_cut(t_ptr,add);
  490. }
  491.  
  492. LOCAL VOID char_delete(TEXTP t_ptr)
  493. {
  494.     LINEP col = t_ptr->cursor_line;
  495.  
  496.     if (t_ptr->xpos < col->len)
  497.     {
  498.         get_undo_col(t_ptr);
  499.         t_ptr->moved++;
  500.         REALLOC(&t_ptr->cursor_line,t_ptr->xpos,-1);
  501.         make_chg(t_ptr->link,LINE_CHANGE,t_ptr->ypos);
  502.         make_chg(t_ptr->link,POS_CHANGE,0);                     /* wg. moved */
  503.     }
  504.     else if (!IS_LAST(col))
  505.     {
  506.         if (col->len+col->nachf->len>MAX_LINE_LEN)
  507.         {
  508.             inote(1, TOOLONG, MAX_LINE_LEN);
  509.             return;
  510.         }
  511.         clr_undo();
  512.         t_ptr->moved++;
  513.         col_concate(&t_ptr->cursor_line);
  514.         t_ptr->text.lines--;
  515.         make_chg(t_ptr->link,SCROLL_UP,t_ptr->ypos+1);
  516.         make_chg(t_ptr->link,LINE_CHANGE,t_ptr->ypos);
  517.         make_chg(t_ptr->link,POS_CHANGE,0);
  518.     }
  519.     else
  520.         end_play();             /* Makro beenden */
  521.     if (t_ptr->loc_opt->umbrechen)
  522.         umbruch(t_ptr);
  523. }
  524.  
  525. LOCAL VOID word_left(TEXTP t_ptr)
  526. {
  527.     WORD    xw;
  528.     LONG    yw;
  529.     UBYTE *str;
  530.     LINEP lauf;
  531.  
  532.     t_ptr->up_down = FALSE;
  533.     lauf = t_ptr->cursor_line;
  534.     xw = t_ptr->xpos;
  535.     yw = t_ptr->ypos;
  536.     str = TEXT(lauf)+xw;
  537.     do                                     /* Ersten Buchstaben finden */
  538.     {
  539.         while(xw==0)
  540.         {
  541.             if (yw==0) return;
  542.             VORG(lauf);
  543.             yw --;
  544.             xw = lauf->len;
  545.             str = TEXT(lauf)+xw;
  546.         }
  547.         xw--;
  548.     }while (!setin(t_ptr->loc_opt->wort_set,*(--str)));
  549.     while(xw>0)                         /* Ersten NICHT-Buchstaben suchen */
  550.     {
  551.         xw--;
  552.         if (!setin(t_ptr->loc_opt->wort_set,*(--str)))
  553.         {
  554.             xw++;
  555.             break;
  556.         }
  557.     }
  558.     t_ptr->cursor_line = lauf;
  559.     t_ptr->xpos = xw;
  560.     t_ptr->ypos = yw;
  561.     make_chg(t_ptr->link,POS_CHANGE,0);
  562. }
  563.  
  564. LOCAL VOID word_right(TEXTP t_ptr)
  565. {
  566.     WORD    xw;
  567.     LONG    yw;
  568.     UBYTE *str;
  569.     LINEP lauf;
  570.  
  571.     t_ptr->up_down = FALSE;
  572.     lauf = t_ptr->cursor_line;
  573.     xw = t_ptr->xpos;
  574.     yw = t_ptr->ypos;
  575.     str = TEXT(lauf)+xw;
  576.     while (TRUE)                        /* erster nicht-wort-Buchstabe */
  577.     {
  578.         if (xw==lauf->len || !setin(t_ptr->loc_opt->wort_set,*str))
  579.             break;
  580.         str++; xw++;
  581.     }
  582.     while (TRUE)                        /* erster wort-Buchstabe */
  583.     {
  584.         while (xw==lauf->len)
  585.         {
  586.             if (IS_LAST(lauf))
  587.                 goto ende;
  588.             NEXT(lauf);
  589.             yw++;
  590.             xw = 0;
  591.             str = TEXT(lauf);
  592.         }
  593.         if (setin(t_ptr->loc_opt->wort_set,*str))
  594.             break;
  595.         str++; xw++;
  596.     }
  597. ende:
  598.     t_ptr->cursor_line = lauf;
  599.     t_ptr->xpos = xw;
  600.     t_ptr->ypos = yw;
  601.     make_chg(t_ptr->link,POS_CHANGE,0);
  602. }
  603.  
  604. LOCAL VOID expand_kurzel(TEXTP t_ptr)
  605. {
  606.     if (krz_loaded)
  607.     {
  608.         blk_demark(t_ptr);
  609.         if (ctrl_mark_mode)
  610.             t_ptr->blk_mark_mode = FALSE;
  611.         t_ptr->up_down = FALSE;
  612.         do_kurzel(t_ptr, FALSE);
  613.     }
  614.     else
  615.         mybeep();
  616. }
  617.  
  618. LOCAL VOID set_block(TEXTP t_ptr)
  619. {
  620.     if (!t_ptr->blk_mark_mode)
  621.     {
  622.         blk_mark(t_ptr, 0);
  623.         t_ptr->blk_mark_mode = TRUE;
  624.     }
  625. }
  626.  
  627. LOCAL VOID unset_block(TEXTP t_ptr)
  628. {
  629.     blk_demark(t_ptr);
  630.     t_ptr->blk_mark_mode = FALSE;
  631. }
  632.  
  633. /* Deselektiert Block und stellt Cursor entsprechend <dir> */
  634. LOCAL VOID deselect_block(TEXTP t_ptr, DIRECTION dir)
  635. {
  636.     switch (dir)
  637.     {
  638.         case UP        :
  639.             desire_x = BildPos(t_ptr->x1, t_ptr->cursor_line, t_ptr->loc_opt->tab, t_ptr->loc_opt->tabsize);
  640.             desire_y = t_ptr->z1;
  641.             break;
  642.         case DOWN    :
  643.             desire_x = BildPos(t_ptr->x2, t_ptr->cursor_line, t_ptr->loc_opt->tab, t_ptr->loc_opt->tabsize);
  644.             desire_y = t_ptr->z2;
  645.             break;
  646.         case LEFT    :
  647.             desire_x = BildPos(t_ptr->x1, t_ptr->cursor_line, t_ptr->loc_opt->tab, t_ptr->loc_opt->tabsize);
  648.             desire_y = t_ptr->z1;
  649.             t_ptr->up_down = FALSE;
  650.             break;
  651.         case RIGHT    :
  652.             desire_x = BildPos(t_ptr->x2, t_ptr->cursor_line, t_ptr->loc_opt->tab, t_ptr->loc_opt->tabsize);
  653.             desire_y = t_ptr->z2;
  654.             t_ptr->up_down = FALSE;
  655.             break;
  656.     }
  657.     blk_demark(t_ptr);
  658.     if (ctrl_mark_mode)
  659.         t_ptr->blk_mark_mode = FALSE;
  660.     Icon_edit(t_ptr->link, DO_GOTO);
  661. }
  662.  
  663.     
  664. GLOBAL BOOLEAN key(TEXTP t_ptr, WINDP window, MKINFO *mk)
  665. {
  666.     WORD        key_code;
  667.  
  668. #if 0
  669. #include "debug.h"
  670.     if (mk->kreturn == (NKF_FUNC|NKF_CTRL|NKF_SHIFT|NK_F10))
  671.     {
  672.         return TRUE;
  673.     }
  674. #endif
  675.  
  676.     /* Sonderbehandlung für ^Y */
  677.     if (mk->ascii_code == 'Y' && (mk->kreturn & NKF_CTRL))
  678.     {
  679.         if (!t_ptr->block)
  680.         {
  681.             pos_korr(window, t_ptr, FALSE);
  682.             t_ptr->blk_mark_mode = FALSE;
  683.             line_delete(t_ptr, mk->shift);
  684.         }
  685.         else
  686.             do_icon(t_ptr->link, DO_CUT);
  687.         t_ptr->up_down = FALSE;
  688.         return TRUE;
  689.     }
  690.  
  691.     if (!t_ptr->block)
  692.         pos_korr(window, t_ptr, FALSE);
  693.     if (mk->kreturn & NKF_FUNC)
  694.     {
  695.         if ((mk->kreturn & NKF_SHIFT) && (mk->kreturn & NKF_CTRL))    /* Shift-Ctrl */
  696.         {
  697.             key_code = mk->kreturn & ~(NKF_FUNC|NKF_SHIFT|NKF_CTRL);
  698.             switch (key_code)
  699.             {
  700.                 case NK_UP :
  701.                     if (ctrl_mark_mode)
  702.                     {
  703.                         set_block(t_ptr);
  704.                         page_up(t_ptr);
  705.                         blk_mark(t_ptr,1);
  706.                     }
  707.                     break;
  708.                 case NK_DOWN :
  709.                     if (ctrl_mark_mode)
  710.                     {
  711.                         set_block(t_ptr);
  712.                         page_down(t_ptr);
  713.                         blk_mark(t_ptr,1);
  714.                     }
  715.                     break;
  716.                 case NK_LEFT :
  717.                     if (ctrl_mark_mode)
  718.                     {
  719.                         set_block(t_ptr);
  720.                         word_left(t_ptr);
  721.                         blk_mark(t_ptr,1);
  722.                     }
  723.                     break;
  724.                 case NK_RIGHT :
  725.                     if (ctrl_mark_mode)
  726.                     {
  727.                         set_block(t_ptr);
  728.                         word_right(t_ptr);
  729.                         blk_mark(t_ptr,1);
  730.                     }
  731.                     break;
  732.                 default:
  733.                     return FALSE;
  734.             }
  735.         }
  736.         else if (mk->kreturn & NKF_SHIFT)                    /* alle Shift-Codes */
  737.         {
  738.             key_code = mk->kreturn & ~(NKF_FUNC|NKF_SHIFT);
  739.             switch (key_code)
  740.             {
  741.                 case NK_CLRHOME:
  742.                     if (ctrl_mark_mode)
  743.                         unset_block(t_ptr);
  744.                     else if (!t_ptr->blk_mark_mode)
  745.                         blk_demark(t_ptr);
  746.                     text_end(t_ptr);
  747.                     if (!ctrl_mark_mode && t_ptr->blk_mark_mode)
  748.                         blk_mark(t_ptr,1);
  749.                     break;
  750.                 case NK_UP:
  751.                     if (ctrl_mark_mode)
  752.                         unset_block(t_ptr);
  753.                     else if (!t_ptr->blk_mark_mode)
  754.                         blk_demark(t_ptr);
  755.                     page_up(t_ptr);
  756.                     if (!ctrl_mark_mode && t_ptr->blk_mark_mode)
  757.                         blk_mark(t_ptr,1);
  758.                     break;
  759.                 case NK_DOWN:
  760.                     if (ctrl_mark_mode)
  761.                         unset_block(t_ptr);
  762.                     else if (!t_ptr->blk_mark_mode)
  763.                         blk_demark(t_ptr);
  764.                     page_down(t_ptr);
  765.                     if (!ctrl_mark_mode && t_ptr->blk_mark_mode)
  766.                         blk_mark(t_ptr,1);
  767.                     break;
  768.                 case NK_LEFT:
  769.                     if (ctrl_mark_mode)
  770.                         unset_block(t_ptr);
  771.                     else if (!t_ptr->blk_mark_mode && t_ptr->block)
  772.                         blk_demark(t_ptr);
  773.                     line_start(t_ptr);
  774.                     if (!ctrl_mark_mode && t_ptr->blk_mark_mode)
  775.                         blk_mark(t_ptr,1);
  776.                     break;
  777.                 case NK_RIGHT:
  778.                     if (ctrl_mark_mode)
  779.                         unset_block(t_ptr);
  780.                     else if (!t_ptr->blk_mark_mode && t_ptr->block)
  781.                         blk_demark(t_ptr);
  782.                     line_end(t_ptr);
  783.                     if (!ctrl_mark_mode && t_ptr->blk_mark_mode)
  784.                         blk_mark(t_ptr,1);
  785.                     break;
  786.                 case NK_BS:
  787.                     word_bs(t_ptr);
  788.                     break;
  789.                 case NK_DEL:
  790.                     word_delete(t_ptr);
  791.                     break;
  792.                 case NK_RET :
  793.                     word_left(t_ptr);
  794.                     char_cr(t_ptr);
  795.                     break;
  796.                 default:
  797.                     return FALSE;
  798.             } /* switch shift */
  799.         } /* if shift */
  800.         else if (mk->kreturn & NKF_CTRL)                 /* alle Control-Codes */
  801.         {
  802.             key_code = mk->kreturn & ~(NKF_FUNC|NKF_CTRL);
  803.             switch (key_code)
  804.             {
  805.                 case NK_UP:
  806.                     if (ctrl_mark_mode)
  807.                     {
  808.                         set_block(t_ptr);
  809.                         line_up(t_ptr);
  810.                         blk_mark(t_ptr,1);
  811.                     }
  812.                     else     /* seitenweise Blättern, für PC-Tastaturen PgUp/Down */
  813.                     {
  814.                         if (!t_ptr->blk_mark_mode && t_ptr->block)
  815.                             deselect_block(t_ptr, UP);
  816.                         else
  817.                         {
  818.                             page_up(t_ptr);
  819.                             if (t_ptr->blk_mark_mode)
  820.                                 blk_mark(t_ptr,1);
  821.                         }
  822.                     }
  823.                     break;
  824.                 case NK_DOWN:
  825.                     if (ctrl_mark_mode)
  826.                     {
  827.                         set_block(t_ptr);
  828.                         line_down(t_ptr);
  829.                         blk_mark(t_ptr,1);
  830.                     }
  831.                     else
  832.                     {
  833.                         if (!t_ptr->blk_mark_mode && t_ptr->block)
  834.                             deselect_block(t_ptr, DOWN);
  835.                         else
  836.                         {
  837.                             page_down(t_ptr);
  838.                             if (t_ptr->blk_mark_mode)
  839.                                 blk_mark(t_ptr,1);
  840.                         }
  841.                     }
  842.                     break;
  843.                 case NK_LEFT:
  844.                     if (ctrl_mark_mode)
  845.                     {
  846.                         set_block(t_ptr);
  847.                         t_ptr->up_down = FALSE;
  848.                         char_left(t_ptr);
  849.                         blk_mark(t_ptr,1);
  850.                     }
  851.                     else
  852.                     {
  853.                         if (!t_ptr->blk_mark_mode && t_ptr->block)
  854.                             deselect_block(t_ptr, LEFT);
  855.                         else
  856.                         {
  857.                             word_left(t_ptr);
  858.                             if (t_ptr->blk_mark_mode)
  859.                                 blk_mark(t_ptr,1);
  860.                         }
  861.                     }
  862.                     break;
  863.                 case NK_RIGHT:
  864.                     if (ctrl_mark_mode)
  865.                     {
  866.                         set_block(t_ptr);
  867.                         t_ptr->up_down = FALSE;
  868.                         char_right(t_ptr);
  869.                         blk_mark(t_ptr,1);
  870.                     }
  871.                     else
  872.                     {
  873.                         if (!t_ptr->blk_mark_mode && t_ptr->block)
  874.                             deselect_block(t_ptr, RIGHT);
  875.                         else
  876.                         {
  877.                             word_right(t_ptr);
  878.                             if (t_ptr->blk_mark_mode)
  879.                                 blk_mark(t_ptr,1);
  880.                         }
  881.                     }
  882.                     break;
  883.                 case NK_TAB:
  884.                     if (!ctrl_mark_mode)
  885.                         t_ptr->blk_mark_mode = FALSE;
  886.                     t_ptr->up_down = FALSE;
  887.                     blk_mark_word(t_ptr);
  888.                     break;
  889.                 case NK_DEL :
  890.                     if (ctrl_mark_mode)
  891.                     {
  892.                         t_ptr->up_down = FALSE;
  893.                         do_icon(t_ptr->link, DO_CUT);
  894.                     }
  895.                     break;
  896.                 case NK_INS:
  897.                     if (ctrl_mark_mode)
  898.                     {
  899.                         t_ptr->up_down = FALSE;
  900.                         do_icon(t_ptr->link, DO_PASTE);
  901.                     }
  902.                     break;
  903.                 case NK_CLRHOME:
  904.                     if (ctrl_mark_mode)
  905.                     {
  906.                         t_ptr->up_down = FALSE;
  907.                         if (t_ptr->block)
  908.                             do_icon(t_ptr->link, DO_COPY);
  909.                         else
  910.                             do_icon(t_ptr->link, DO_LINECOPY);
  911.                     }
  912.                     break;
  913.                 default:
  914.                     return FALSE;
  915.             } /* switch ctrl */
  916.         } /* if ctrl */
  917.         else if (mk->kreturn & NKF_ALT)                        /* alle Alt-Codes */
  918.         {
  919.             key_code = mk->kreturn & ~(NKF_FUNC|NKF_ALT);
  920.             switch (key_code)
  921.             {
  922.                 default:
  923.                     return FALSE;
  924.             } /* switch alt */
  925.         } /* if alt */
  926.         else                                        /* alles restliche Funktionscodes */
  927.         {
  928.             key_code = mk->kreturn & ~NKF_FUNC;
  929.             switch (key_code)
  930.             {
  931.                 case NK_ESC :
  932.                     expand_kurzel(t_ptr);
  933.                     break;
  934.                 case NK_TAB:
  935.                     tabulator(t_ptr);
  936.                     break;
  937.                 case NK_RET:
  938.                 case (NK_ENTER|NKF_NUM) :
  939.                     char_cr(t_ptr);
  940.                     break;
  941.                 case NK_CLRHOME:
  942.                     if (ctrl_mark_mode)
  943.                         unset_block(t_ptr);
  944.                     else if (!t_ptr->blk_mark_mode)
  945.                         blk_demark(t_ptr);
  946.                     text_start(t_ptr);
  947.                     if (!ctrl_mark_mode && t_ptr->blk_mark_mode)
  948.                         blk_mark(t_ptr,1);
  949.                     break;
  950.                 case NK_UNDO:
  951.                     Icon_edit(t_ptr->link, DO_UNDO);
  952.                     break;
  953.                 case NK_UP:
  954.                     if ((ctrl_mark_mode || !t_ptr->blk_mark_mode) && t_ptr->block)
  955.                     {
  956.                         deselect_block(t_ptr, UP);
  957.                         break;
  958.                     }
  959.                     line_up(t_ptr);
  960.                     if (!ctrl_mark_mode && t_ptr->blk_mark_mode)
  961.                         blk_mark(t_ptr,1);
  962.                     break;
  963.                 case NK_DOWN:
  964.                     if ((ctrl_mark_mode || !t_ptr->blk_mark_mode) && t_ptr->block)
  965.                     {
  966.                         deselect_block(t_ptr, DOWN);
  967.                         break;
  968.                     }
  969.                     line_down(t_ptr);
  970.                     if (!ctrl_mark_mode && t_ptr->blk_mark_mode)
  971.                         blk_mark(t_ptr,1);
  972.                     break;
  973.                 case NK_LEFT:
  974.                     t_ptr->up_down = FALSE;
  975.                     if ((ctrl_mark_mode || !t_ptr->blk_mark_mode) && t_ptr->block)
  976.                     {
  977.                         deselect_block(t_ptr, LEFT);
  978.                         break;
  979.                     }
  980.                     char_left(t_ptr);
  981.                     if (!ctrl_mark_mode && t_ptr->blk_mark_mode)
  982.                         blk_mark(t_ptr,1);
  983.                     break;
  984.                 case NK_RIGHT:
  985.                     t_ptr->up_down = FALSE;
  986.                     if ((ctrl_mark_mode || !t_ptr->blk_mark_mode) && t_ptr->block)
  987.                     {
  988.                         deselect_block(t_ptr, RIGHT);
  989.                         break;
  990.                     }
  991.                     char_right(t_ptr);
  992.                     if (!ctrl_mark_mode && t_ptr->blk_mark_mode)
  993.                         blk_mark(t_ptr,1);
  994.                     break;
  995.                 case NK_BS:
  996.                     if (!ctrl_mark_mode)
  997.                         t_ptr->blk_mark_mode = FALSE;
  998.                     t_ptr->up_down = FALSE;
  999.                     if (t_ptr->block)
  1000.                         blk_delete(t_ptr);
  1001.                     else
  1002.                         char_bs(t_ptr);
  1003.                     break;
  1004.                 case NK_DEL:
  1005.                     if (!ctrl_mark_mode)
  1006.                         t_ptr->blk_mark_mode = FALSE;
  1007.                     t_ptr->up_down = FALSE;
  1008.                     if (t_ptr->block)
  1009.                         blk_delete(t_ptr);
  1010.                     else
  1011.                         char_delete(t_ptr);
  1012.                     break;
  1013.                 case NK_M_PGUP:                /* Mac: page up -> shift-up */
  1014.                     if (ctrl_mark_mode)
  1015.                         unset_block(t_ptr);
  1016.                     else if (!t_ptr->blk_mark_mode)
  1017.                         blk_demark(t_ptr);
  1018.                     page_up(t_ptr);
  1019.                     if (!ctrl_mark_mode && t_ptr->blk_mark_mode)
  1020.                         blk_mark(t_ptr,1);
  1021.                     break;
  1022.                 case NK_M_PGDOWN:             /* Mac: page down -> shift-down */
  1023.                     if (ctrl_mark_mode)
  1024.                         unset_block(t_ptr);
  1025.                     else if (!t_ptr->blk_mark_mode)
  1026.                         blk_demark(t_ptr);
  1027.                     page_down(t_ptr);
  1028.                     if (!ctrl_mark_mode && t_ptr->blk_mark_mode)
  1029.                         blk_mark(t_ptr,1);
  1030.                     break;
  1031.                 case NK_M_END:                 /* Mac: end -> shift-home */
  1032.                     if (ctrl_mark_mode)
  1033.                         unset_block(t_ptr);
  1034.                     else if (!t_ptr->blk_mark_mode)
  1035.                         blk_demark(t_ptr);
  1036.                     text_end(t_ptr);
  1037.                     if (!ctrl_mark_mode && t_ptr->blk_mark_mode)
  1038.                         blk_mark(t_ptr,1);
  1039.                     break;
  1040.                 default:
  1041.                     return FALSE;
  1042.             } /* switch func */
  1043.         }
  1044.     } /* if NKF_FUNC */
  1045.     else                                                    /* keine Funktionstaste */
  1046.     {
  1047.             if (mk->ascii_code)
  1048.             /* Kein Cntrl und ascii nicht Null */
  1049.             {
  1050.                 t_ptr->blk_mark_mode = FALSE;
  1051.                 char_insert(t_ptr, mk->ascii_code);
  1052.                 if (krz_loaded)
  1053.                     do_kurzel(t_ptr, TRUE);
  1054.             }
  1055.             else
  1056.                 return FALSE;
  1057.     }
  1058.     return TRUE;
  1059. }
  1060.